package trabalhoprog3;//
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class TrabalhoProg3 {
    //***********************  FORNECEDOR ****************************
    
    static protected ArrayList<Fornecedor> listaDeFornecedores = new ArrayList<Fornecedor>();
    static protected int quantidadeDeFornecedores = 0;
    
    protected static void cadastrarFornecedorViaTeclado(){
        Fornecedor novoFornecedor = new Fornecedor();
        
        novoFornecedor.nome = novoFornecedor.cadastrarNome(novoFornecedor.nome);
        novoFornecedor.endereco = novoFornecedor.cadastrarEndereco(novoFornecedor.endereco);
        novoFornecedor.codigo = novoFornecedor.cadastrarCodigo(novoFornecedor.codigo);
        novoFornecedor.telefone = novoFornecedor.cadastrarTelefone(novoFornecedor.telefone);
        listaDeFornecedores.add(quantidadeDeFornecedores, novoFornecedor);
        quantidadeDeFornecedores++;
    }
    
    protected static Fornecedor lerFornecedor(Scanner leitor){
        Fornecedor fornecedorTemporario = new Fornecedor();
        
        fornecedorTemporario.nome = leitor.nextLine();
        fornecedorTemporario.endereco = leitor.nextLine();
        fornecedorTemporario.codigo = Integer.parseInt(leitor.nextLine());
        fornecedorTemporario.telefone = Integer.parseInt(leitor.nextLine());
        return fornecedorTemporario;
    }
    
    protected static void leituraDosFornecedores() throws FileNotFoundException, IOException{
        File arquivo = new File("Fornecedores.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            
            listaDeFornecedores.clear();
            quantidadeDeFornecedores=0;
            while(leitor.hasNext()){
                listaDeFornecedores.add(quantidadeDeFornecedores, lerFornecedor(leitor));
                quantidadeDeFornecedores++;
            }
            leitor.close();
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
        }
    }
    
    protected static void listarFornecedores(){
        for(int i=0; i<quantidadeDeFornecedores; i++){
            System.out.println("\n\nCódigo:   "+listaDeFornecedores.get(i).codigo);
            System.out.println("Nome:   "+listaDeFornecedores.get(i).nome);
            System.out.println("Endereco:   "+listaDeFornecedores.get(i).endereco);
            System.out.println("Telefone:   "+listaDeFornecedores.get(i).telefone);
        }
        System.out.print("\n\n");
    }
    
    protected static boolean verCadastroDeFornecedorNoSistemaPorCodigo(int codigoDoFornecedor){
        for(int i = 0; i< quantidadeDeFornecedores; i++){
            if(codigoDoFornecedor ==listaDeFornecedores.get(i).codigo){
                return true;
            }
        }
        return false;
    }
    
    protected boolean verCadastroDeFornecedorNoSistemaPorNome(String nomeDoFornecedor){
        for(int i = 0; i< quantidadeDeFornecedores; i++){
            if(nomeDoFornecedor.equals(listaDeFornecedores.get(i).nome)){
                return true;
            }
        }
        return false;
    }
    
    protected static void salvarFornecedores() throws IOException{
        File arquivo = new File("Fornecedores.txt");
        FileWriter escrevedor = new FileWriter(arquivo);
        Fornecedor fornecedor;
        
        for(int i = 0;   i<quantidadeDeFornecedores;        i++){
            fornecedor = listaDeFornecedores.get(i);
            gravarFornecedor(fornecedor,escrevedor);
        }
        escrevedor.close();
    }
    
    protected static void listarDadosDosFornecedores(){
        for(int i = 0;  i<quantidadeDeFornecedores; i++){
            System.out.print("FORNECEDOR "+(i+1));
            System.out.print("\nNome:  "+(String) listaDeFornecedores.get(i).nome);
            System.out.print("\nEndereço:  "+(String) listaDeFornecedores.get(i).endereco);
            System.out.print("\nCódigo:  "+(int) listaDeFornecedores.get(i).codigo);
            System.out.print("\nTelefone:  "+(int) listaDeFornecedores.get(i).telefone);
            System.out.print("\n\n\n");
        }
    }
    
    static Fornecedor retornarFornecedorPeloCodigo(int codigoDoFornecedor){
        for(int i=0;i<quantidadeDeFornecedores;i++){
            if(listaDeFornecedores.get(i).codigo == codigoDoFornecedor){
                return listaDeFornecedores.get(i);
            }
        }
        return null;
    }
    
    //************************************************* INSTANTE ***************************************************
    protected static Instante retornarDataAtual(){
        Instante dataAtual = new Instante();
        
        dataAtual.dia = dataAtual.setarDiaAtual();
        dataAtual.mes = dataAtual.setarMesAtual();
        dataAtual.ano = dataAtual.setarAnoAtual();
        dataAtual.hora = dataAtual.setarHoraAtual();
        dataAtual.minuto = dataAtual.setarMinutoAtual();
        dataAtual.segundo = dataAtual.setarSegundoAtual();
        return dataAtual;
    }
    
    protected static Instante configurarData(){
        Instante dataAtual = new Instante();
        
        dataAtual.dia = dataAtual.setarData(dataAtual.dia);
        dataAtual.mes = dataAtual.setarMes(dataAtual.mes);
        dataAtual.ano = dataAtual.setarAno(dataAtual.ano);
        dataAtual.hora = dataAtual.setarHora(dataAtual.hora);
        dataAtual.minuto = dataAtual.setarMinuto(dataAtual.minuto);
        dataAtual.segundo = dataAtual.setarSegundo(dataAtual.segundo);
        return dataAtual;
    }
    
    //***********************  CLIENTE *******************************
    
    static ArrayList<Cliente> listaDeClientes = new ArrayList<Cliente>();
    static int quantidadeDeClientes = 0;
    
    protected static void cadastrarClienteViaTeclado(){
        Cliente novoCliente = new Cliente();
        
        novoCliente.nome = novoCliente.cadastrarNome(novoCliente.nome);
        novoCliente.endereco = novoCliente.cadastrarEndereco(novoCliente.endereco);
        novoCliente.cpf = novoCliente.cadastrarCpf(novoCliente.cpf);
        listaDeClientes.add(quantidadeDeClientes,novoCliente);
        quantidadeDeClientes++;
    }
    
    protected static Cliente lerCliente(Scanner leitor){
        Cliente clienteTemporario = new Cliente();
        
        clienteTemporario.nome = leitor.nextLine();
        clienteTemporario.endereco = leitor.nextLine();
        clienteTemporario.cpf = leitor.nextLine();
        return clienteTemporario;
    }
    
    protected static void leituraDosClientes() throws FileNotFoundException, IOException{
        File arquivo = new File("Clientes.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            
            listaDeClientes.clear();
            while(leitor.hasNext()){
                listaDeClientes.add(quantidadeDeClientes,lerCliente(leitor));
                quantidadeDeClientes++;
            }
            leitor.close();
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
        }
    }
            
    protected static void salvarClientes() throws IOException{
        File arquivo = new File("Clientes.txt");
        FileWriter escrevedor = new FileWriter(arquivo);
        Cliente cliente;
        
        for(int i = 0; i < quantidadeDeClientes; i++){
            cliente = listaDeClientes.get(i);
            gravarCliente(cliente,escrevedor);
        }
        escrevedor.close();
    }
    
    protected static void listarClientes(){
        for(int i = 0;  i<quantidadeDeClientes; i++){
            System.out.print("Cliente "+(i+1));
            System.out.print("\nNome:  "+(String) listaDeClientes.get(i).nome);
            System.out.print("\nEndereço:  "+(String) listaDeClientes.get(i).endereco);
            System.out.print("\nC.P.F.:  "+(String) listaDeClientes.get(i).cpf);
            System.out.print("\n\n\n");
        }
    }
    
    protected static boolean verCadastroDoClienteNoSistemaPorCPF(String cpf){
        for(int i=0;i < quantidadeDeClientes; i++){
            if(listaDeClientes.get(i).cpf.equals(cpf)){
                return true;
            }
        }
        return false;
    }
    
    protected static int retornarPosicaoDoClienteCPF(String cpf){
        for(int i=0;i < quantidadeDeClientes; i++){
            if(listaDeClientes.get(i).cpf.equals(cpf)){
                return i;
            }
        }
        return -1;
    }
    
    protected static Cliente retornarClientepeloCPF(String cpf){
        for(int i=0;i < quantidadeDeClientes; i++){
            if(listaDeClientes.get(i).cpf.equals(cpf)){
                return listaDeClientes.get(i);
            }
        }
        return null;
    }    
    
    //****************************** ÍTEM ***************************************
    protected static ArrayList<Item> listaDeItens = new ArrayList<Item>();
    protected static int quantidadeDeItens = 0;
    protected static int quantidadeDeUnidades = 0;
    
    
    
    protected static void cadastrarItemViaTeclado(){
        Item novoItem = new Item();
        
        novoItem.nome = novoItem.cadastrarNome(novoItem.nome);
        novoItem.codigo = novoItem.cadastrarCodigo(novoItem.codigo);
        novoItem.precoDeVenda = novoItem.inserirPrecoDeVenda(novoItem.precoDeVenda);
        novoItem.fornecedor = novoItem.inserirFornecedor(novoItem.fornecedor);
        listaDeItens.add(quantidadeDeItens, novoItem);
        quantidadeDeItens++;
    }
    
    protected static boolean verCadastroDoItemNoSistemaPorNome(String nomeDoItem){
        for(int i = 0; i< quantidadeDeItens; i++){
            if(nomeDoItem.equals(listaDeItens.get(i).nome)){
                return true;
            }
        }
        return false;
    }
    
    protected static Item retornarItemPorCodigo(int codigoDoItem){
        for(int i = 0; i< quantidadeDeItens; i++){
            if(codigoDoItem == listaDeItens.get(i).codigo){
                return listaDeItens.get(i);
            }
        }
        return null;
    }
    
    protected static boolean verificarDisponibilidadeZeroDoItem(String nomeDoItem){
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                if(listaDeItens.get(i).quantidadeDisponivel>0){
                    return true;
                }
            }
        }
        return false;
    }
    
    protected static int retornarPosicaoDoNomeDoItem(String nomeDoItem){
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)) return i;
        }
        return -1;
    }       
    
    protected static boolean verificarDisponibilidadeDoItem(String nomeDoItem){
        return verCadastroDoItemNoSistemaPorNome(nomeDoItem) || verificarDisponibilidadeZeroDoItem(nomeDoItem);
    }
    
    protected static Item retornarItemDadoNome(String nomeDoItem){
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                return listaDeItens.get(i);
            }
        }
        return null;
    }
    
    protected static void imprimirDadosDoItem(Item item){
        System.out.println("\n\nCódigo: "+item.codigo);
        System.out.println("Nome Do Fornecedor: "+item.fornecedor.nome);
        System.out.println("Nome Do Código: "+item.fornecedor.codigo);
        System.out.println("Quantidade em estoque desse fornecedor: "+item.quantidadeTotalEmEstoque);
        System.out.println("Quantidade reservada em estoque desse fornecedor: "+item.quantidadeReservada);
        System.out.println("Quantidade em disponível em estoque desse fornecedor: "+item.quantidadeDisponivel);
    }
    
    protected static void listarDadosDoItem(){
        Item item;
        int quantidadeTotalEmEstoque = 0;
        int quantidadeTotalReservada = 0;
        int quantidadeTotalDisponivel = 0;
        String nomeDoItem;
        Scanner leitor = new Scanner(System.in);
        
        System.out.print("Digite o nome do Cliente:   ");
        nomeDoItem = leitor.nextLine();
        
        if(!verCadastroDoItemNoSistemaPorNome(nomeDoItem)){
            System.out.println("\nItem não cadastrado!!\n\n");
        }
        else{
            for(int i = 0;i<quantidadeDeItens;i++){
                item = listaDeItens.get(i);
                if(item.nome.equals(nomeDoItem)){
                    imprimirDadosDoItem(item);
                    quantidadeTotalEmEstoque += item.quantidadeTotalEmEstoque;
                    quantidadeTotalDisponivel += item.quantidadeDisponivel;
                    quantidadeTotalReservada += item.quantidadeReservada;
                }
            }
            System.out.println("O total de unidades em estoque deste ítem é:  "+quantidadeTotalEmEstoque);
            System.out.println("O total de unidades reservadas deste ítem é:  "+quantidadeTotalReservada);
            System.out.println("O total de unidades disponíveis deste ítem é:  "+quantidadeTotalDisponivel);
        }
    }
    
    protected static int retornarNumeroDeUnidadesDisponiveisDoItem(String nomeDoItem){
        int numeroDeUnidades = 0;
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){                numeroDeUnidades += listaDeItens.get(i).quantidadeDisponivel;
            }
        }
        return numeroDeUnidades;
    }
    
    protected static int retornarNumeroTotalDeUnidadesDoItem(String nomeDoItem){
        int numeroDeUnidades = 0;
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                numeroDeUnidades += listaDeItens.get(i).quantidadeTotalEmEstoque;
            }
        }
        return numeroDeUnidades;
    }
    
    protected static int retornarNumeroDeUnidadesReservadasDoItem(String nomeDoItem){
        int numeroDeUnidades = 0;
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                numeroDeUnidades += listaDeItens.get(i).quantidadeReservada;
            }
        }
        return numeroDeUnidades;
    }
    
    protected static void consultarPrecoDeUmItemPorCodigo(){
        System.out.print("Digite o código do item:   ");

        Scanner leitor = new Scanner(System.in);
        int codigoDoItem = leitor.nextInt();
        Item item = retornarItemPorCodigo(codigoDoItem);
        
        if(item == null){
            System.out.println("Item não cadastrado!");
        }
        else{
            System.out.println("O preco do item é"+item.precoDeVenda);
        }
        System.out.print("\n\n");
    }
    
    protected static void gravarFornecedor(Fornecedor fornecedor,FileWriter escrevedor) throws IOException{
        escrevedor.write(fornecedor.nome);
        escrevedor.write("\n");
        
        escrevedor.write(fornecedor.endereco);
        escrevedor.write("\n");
        
        escrevedor.write(Integer.toString(fornecedor.codigo));
        escrevedor.write("\n");
        
        escrevedor.write(Integer.toString(fornecedor.telefone));
        escrevedor.write("\n");
    }
    
    protected static void gravarItem(Item item,FileWriter escrevedor) throws IOException{
        escrevedor.write(item.nome);
        escrevedor.write("\n");

        escrevedor.write(Integer.toString(item.codigo));
        escrevedor.write("\n");

        escrevedor.write(Integer.toString(item.quantidadeTotalEmEstoque));
        escrevedor.write("\n");

        escrevedor.write(Integer.toString(item.quantidadeDisponivel));
        escrevedor.write("\n");

        escrevedor.write(Integer.toString(item.quantidadeReservada));
        escrevedor.write("\n");

        escrevedor.write(Float.toString(item.precoDeCusto));
        escrevedor.write("\n");
        
        escrevedor.write(Float.toString(item.precoDeVenda));
        escrevedor.write("\n");
        
        escrevedor.write(Float.toString(item.margemDeLucro));
        escrevedor.write("\n");
        
        gravarFornecedor(item.fornecedor,escrevedor);
    }
    
    protected static void salvarItens() throws IOException{
        File arquivo = new File("Itens.txt"); //ou estoque
        FileWriter escrevedor = new FileWriter(arquivo);
        Item item;
        
        for(int i = 0; i < quantidadeDeItens; i++){
            item = listaDeItens.get(i);
            gravarItem(item,escrevedor);
        }
        escrevedor.close();
    }
    
    protected static Item lerItem(Scanner leitor){
        Item itemTemporario = new Item();
        
        itemTemporario.nome = leitor.nextLine();
        itemTemporario.codigo = Integer.parseInt(leitor.nextLine());
        itemTemporario.quantidadeTotalEmEstoque = Integer.parseInt(leitor.nextLine());
        itemTemporario.quantidadeDisponivel = Integer.parseInt(leitor.nextLine());
        itemTemporario.quantidadeReservada = Integer.parseInt(leitor.nextLine());
        itemTemporario.precoDeCusto = Float.parseFloat(leitor.nextLine());
        itemTemporario.precoDeVenda = Float.parseFloat(leitor.nextLine());
        itemTemporario.margemDeLucro = Float.parseFloat(leitor.nextLine());
        itemTemporario.fornecedor = lerFornecedor(leitor);
        return itemTemporario;
    }
    
    protected static void leituraDosItens() throws FileNotFoundException, IOException{
        File arquivo = new File("Itens.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            
            quantidadeDeItens=0;
            listaDeItens.clear();
            while(leitor.hasNext()){
                listaDeItens.add(quantidadeDeItens,lerItem(leitor));
                quantidadeDeItens++;
            }
            leitor.close();
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
        }
    }
    
    
    protected static void imprimirSituacaoDoProduto(String nomeDoproduto){
        int quantidadeTotalDisponivel = 0;
        int quantidadeTotalReservada = 0;
        int quantidadeTotalEmEstoque = 0;
        
        System.out.print("\n\n");
        for(int i=0;i<quantidadeDeItens;i++){
            System.out.print("Fornecedor "+listaDeItens.get(i).fornecedor.nome);
            System.out.print("Unidades:\n");
            System.out.print("Disponíveis: "+retornarNumeroDeUnidadesDisponiveisDoItem(listaDeItens.get(i).fornecedor.nome));
            System.out.println("Reservadas: "+retornarNumeroDeUnidadesReservadasDoItem(listaDeItens.get(i).fornecedor.nome));
            System.out.println("Número total: "+retornarNumeroTotalDeUnidadesDoItem(listaDeItens.get(i).fornecedor.nome));
            
        }
        System.out.print("\nA quantidade total de unidades disponíveis do produto eh: "+quantidadeTotalDisponivel);
        System.out.print("\nA quantidade total de unidades reservadas do produto eh: "+quantidadeTotalReservada);
        System.out.print("\nA quantidade total de em estoque unidades do produto eh: "+quantidadeTotalEmEstoque);
        System.out.print("\n\n\n");
        
    }
    
    protected static void situacaoAtualDoEstoqueParaUmProduto(){
        Scanner leitor = new Scanner(System.in);
        String nomeDoProduto;
        
        System.out.println("Digite o nome do produto:   ");
        nomeDoProduto = leitor.nextLine();
        
        while(!verCadastroDoItemNoSistemaPorNome(nomeDoProduto)){
            System.out.println("Produto não cadastrado!!\nDigite novamente:   ");
            nomeDoProduto = leitor.nextLine();
        }
        
        imprimirSituacaoDoProduto(nomeDoProduto);
    }
    
    protected static void resumoDasituacaoAtualDoEstoque(){
        for(int i=0;i<quantidadeDeItens;i++){
            imprimirDadosDoItem(listaDeItens.get(i));
        }
        System.out.print("\n\n");
    }
    
    //******************************* COMPRAS  ****************************************
    static ArrayList<Compra> historicoDeCompras = new ArrayList<Compra>();
    static int numeroDeComprasFeitas = 0;
    
    protected static void realizarCompra(){
        Compra novaCompra = new Compra();
        Scanner leitor = new Scanner(System.in);
        
        novaCompra.fornecedorDaCompra = novaCompra.escolherFornecedor(novaCompra.fornecedorDaCompra);
        
        do{
            novaCompra.listaDeItensComprados.add(novaCompra.quantidadeDeItensComprados,novaCompra.escolherItem());
            novaCompra.quantidadeDeItensComprados++;
            
            historicoDeCompras.add(numeroDeComprasFeitas,novaCompra);
            numeroDeComprasFeitas++;
            
            System.out.print("\n\nItem comprado com Sucesso!!\n\n");
            System.out.print("Deseja fazer comprar um novo Item??\n");
            System.out.print("Digite y se sim ou qualquer outrocaracter caso contrário   \n");
            
        }while(leitor.nextLine().matches("y"));
    }
    
    protected static void gravarCompra(Compra compra,FileWriter escrevedor) throws IOException{
        gravarFornecedor(compra.fornecedorDaCompra,escrevedor);
        escrevedor.write(Integer.toString(compra.quantidadeDeItensComprados));
        escrevedor.write("\n");
        gravarListaDeItens(compra.listaDeItensComprados,escrevedor);
        gravarData(compra.entrada,escrevedor);
    }
    
    protected static void salvarHistoricoDeCompras() throws IOException{
        File arquivo = new File("Historico de Compras.txt");
        FileWriter escrevedor = new FileWriter(arquivo);
        
        for(int i=0;i<numeroDeComprasFeitas;i++){
            gravarCompra(historicoDeCompras.get(i),escrevedor);           
        }
        escrevedor.close();
    }
    
    protected static ArrayList<Item> lerItensComprados(Scanner leitor,int quantidadeDeItensComprados){
        ArrayList<Item> listaDeItensComprados = new ArrayList<Item>();
        
        for(int i=0;i<quantidadeDeItensComprados;i++){
            Item item = new Item();
            
            item.nome = leitor.nextLine();
            item.codigo = Integer.parseInt(leitor.nextLine());
            item.quantidadeReservada = Integer.parseInt(leitor.nextLine());
            listaDeItensComprados.add(i,item);
        }
        return listaDeItensComprados;
    }
    
    protected static Compra lerCompra(Scanner leitor) throws IOException{
        Compra compraTemporaria = new Compra();
        
        compraTemporaria.fornecedorDaCompra = lerFornecedor(leitor);
        compraTemporaria.quantidadeDeItensComprados = Integer.parseInt(leitor.nextLine());
        compraTemporaria.listaDeItensComprados = lerItensComprados(leitor,compraTemporaria.quantidadeDeItensComprados);
        compraTemporaria.entrada = lerData(leitor);
        return compraTemporaria;
    }
    
    protected static void carregarHistoricoDeCompras() throws FileNotFoundException, IOException{
        File arquivo = new File("Historico de Compras.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            
            historicoDeCompras.clear();
            numeroDeComprasFeitas=0;
            while(leitor.hasNext()){
                historicoDeCompras.add(numeroDeComprasFeitas,lerCompra(leitor));
                numeroDeComprasFeitas++;
            }
            leitor.close();
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
        }
    }
    
    protected static void imprimirCompra(Compra compra){
        System.out.print("Data de entrada");
        imprimirData(compra.entrada);
        System.out.print("Nome do fornecedor: "+compra.fornecedorDaCompra.nome);
        System.out.print("Código do fornecedor: "+compra.fornecedorDaCompra.codigo);
        
        for(int i=0;i<compra.quantidadeDeItensComprados;i++){
            imprimirDadosDoItem(compra.listaDeItensComprados.get(i));
        }
    }
    
    protected static void exibirHistoricoDeCompras() throws IOException{
        numeroDeComprasFeitas = 0;
        
        carregarHistoricoDeCompras();
        for(int i = 0; i<numeroDeComprasFeitas;i++){
            imprimirCompra(historicoDeCompras.get(i));
        }
        historicoDeCompras.clear();
        numeroDeComprasFeitas = 0;
    }
    
    //***************************************************************************
    
    //******************************* PEDIDOS*************************************
    static ArrayList<Pedido> listaDePedidosEmAberto = new ArrayList<Pedido>();
    static int quantidadeDePedidosEmAberto = 0; 
    static int quantidadeDePedidosEncerrados = 0;
    static int quantidadeDePedidosCancelados = 0;
    
    protected static void reservarUnidades(int numeroDeUnidades,String nomeDoItem){
        for(int i=0;i<quantidadeDeItens && (numeroDeUnidades > 0);i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                if(listaDeItens.get(i).quantidadeDisponivel < numeroDeUnidades){
                    numeroDeUnidades -= listaDeItens.get(i).quantidadeDisponivel;
                    listaDeItens.get(i).quantidadeReservada = listaDeItens.get(i).quantidadeDisponivel;
                    listaDeItens.get(i).quantidadeDisponivel = 0;
                }
                else{
                    listaDeItens.get(i).quantidadeReservada = numeroDeUnidades;
                    listaDeItens.get(i).quantidadeDisponivel -= numeroDeUnidades;
                    numeroDeUnidades = 0;
                }
            }
        }
    }
    
    protected static void aniquilarUnidades(int numeroDeUnidades,String nomeDoItem){ //corrigir
        for(int i=0;i<quantidadeDeItens && (numeroDeUnidades > 0);i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                if(listaDeItens.get(i).quantidadeReservada < numeroDeUnidades){
                    numeroDeUnidades -= listaDeItens.get(i).quantidadeReservada;
                    listaDeItens.get(i).quantidadeReservada = 0;
                    listaDeItens.get(i).quantidadeTotalEmEstoque = listaDeItens.get(i).quantidadeReservada;
                }
                else{
                    listaDeItens.get(i).quantidadeReservada -= numeroDeUnidades;
                    listaDeItens.get(i).quantidadeTotalEmEstoque -= numeroDeUnidades;
                    numeroDeUnidades = 0;
                }
            }
        }
    }
    
    protected static void restaurarUnidades(int numeroDeUnidades,String nomeDoItem){
        for(int i=0;(i<quantidadeDeItens) && (numeroDeUnidades>0);i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                listaDeItens.get(i).quantidadeDisponivel += listaDeItens.get(i).quantidadeReservada;
                if(listaDeItens.get(i).quantidadeReservada < numeroDeUnidades){
                    numeroDeUnidades -= listaDeItens.get(i).quantidadeReservada;
                    listaDeItens.get(i).quantidadeReservada = 0;
                }
                else{
                    listaDeItens.get(i).quantidadeReservada -= numeroDeUnidades;
                    numeroDeUnidades = 0;
                }
            }
        }
    }
    
    protected static float somatorioDosPrecosDeCustoDoItem(String nomeDoItem){
        float somatorio = 0;
        
        for(int i = 0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                somatorio += (listaDeItens.get(i).precoDeCusto)*(listaDeItens.get(i).quantidadeTotalEmEstoque);
            }
        }
        return somatorio;
    }
    
    protected static float calcularPrecoDeCustoDoItem(String nomeDoItem){
        return somatorioDosPrecosDeCustoDoItem(nomeDoItem)/retornarNumeroTotalDeUnidadesDoItem(nomeDoItem);
    }
    
    protected static void atualizarPrecoDoItem(String nomeDoItem){
        for(int i=0;i<quantidadeDeItens;i++){
            if(listaDeItens.get(i).nome.equals(nomeDoItem)){
                listaDeItens.get(i).precoDeCusto = calcularPrecoDeCustoDoItem(nomeDoItem);
            }
        }
    }
    
    protected static void abrirPedido(){
        Pedido novoPedido = new Pedido();
        
        novoPedido.clienteSolicitador = novoPedido.selecionarCliente(novoPedido.clienteSolicitador);
        novoPedido.itensPedidos = novoPedido.selecionarItens(novoPedido.itensPedidos);
        novoPedido.numeroDoPedido = novoPedido.inserirNumeroDopedido(novoPedido.numeroDoPedido);
        
        //outros metodos
        listaDePedidosEmAberto.add(quantidadeDePedidosEmAberto, novoPedido);
        quantidadeDePedidosEmAberto++;
    }
    
    protected static void retirarItensDoEstoque(int posicaoDoPedido){
        //for(int i=0;i<quantidadeDePedidosEmAberto;i++){
        
        for(int i=0;  i<listaDePedidosEmAberto.get(posicaoDoPedido).quantidadeDeItensPedidos;  i++){
            int numeroDeUnidades = listaDePedidosEmAberto.get(posicaoDoPedido).itensPedidos.get(i).quantidadeReservada;
            String nomeDoItem = listaDePedidosEmAberto.get(posicaoDoPedido).itensPedidos.get(i).nome;
            
            for(int j=0; j< quantidadeDeItens; j++){
                if(nomeDoItem.equals(listaDeItens.get(j).nome)){
                    aniquilarUnidades(numeroDeUnidades,nomeDoItem);
                }
            }
        }
    }
    
    protected static int retornarPosicaoDoPedidoViaNumero(int numeroDoPedido){
        for(int i=0;i<quantidadeDePedidosEmAberto;i++){
            if(listaDePedidosEmAberto.get(i).numeroDoPedido == numeroDoPedido){
                return i;
            }
        }
        return -1;
    }    
    
    protected static void gravarCliente(Cliente cliente,FileWriter escrevedor) throws IOException{
        escrevedor.write(cliente.nome);
        escrevedor.write("\n");
        escrevedor.write(cliente.endereco);
        escrevedor.write("\n");
        escrevedor.write(cliente.cpf);
        escrevedor.write("\n");
    }
    
    protected static void gravarData(Instante data,FileWriter escrevedor) throws IOException{
        escrevedor.write(Integer.toString(data.dia));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(data.mes));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(data.ano));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(data.hora));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(data.minuto));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(data.segundo));
        escrevedor.write("\n");
    }
    
    protected static Instante lerData(Scanner leitor) throws IOException{
        Instante data = new Instante();
        
        data.dia = Integer.parseInt(leitor.nextLine());
        data.mes = Integer.parseInt(leitor.nextLine());
        data.ano = Integer.parseInt(leitor.nextLine());
        data.hora = Integer.parseInt(leitor.nextLine());
        data.minuto = Integer.parseInt(leitor.nextLine());
        data.segundo = Integer.parseInt(leitor.nextLine());
        return data;
    }
    
    protected static void gravarListaDeItens(ArrayList<Item> listaDeItensPedidos, FileWriter escrevedor) throws IOException{
        int numeroDeGravacoes = listaDeItensPedidos.size();
        
        for(int i=0;i<numeroDeGravacoes;i++){
            escrevedor.write(listaDeItensPedidos.get(i).nome);
            escrevedor.write("\n");
            escrevedor.write(Integer.toString(listaDeItensPedidos.get(i).codigo));
            escrevedor.write("\n");
            escrevedor.write(Integer.toString(listaDeItensPedidos.get(i).quantidadeReservada));
            escrevedor.write("\n");
        }
    }
    
    protected static void gravarPedidoEmHistorico(int posicaoDoPedido) throws IOException{
        File arquivo = new File("Historico de Pedidos.txt");
        
        if(!arquivo.exists()){
            FileWriter escrevedor = new FileWriter(arquivo);
        }
        FileWriter escrevedor = new FileWriter(arquivo,true); //faz o ponteiro ir pro final do arquivo
        gravarPedido(listaDePedidosEmAberto.get(posicaoDoPedido),escrevedor);
    }
    
    protected static void gravarPedidoEmHistoricoDeCancelamento(Pedido pedido) throws IOException{
        File arquivo = new File("Historico de Pedidos Cancelados.txt");
        
        if(!arquivo.exists()){
            FileWriter escrevedor = new FileWriter(arquivo);
        }
        FileWriter escrevedor = new FileWriter(arquivo,true); //faz o ponteiro ir pro final do arquivo
        gravarPedido(pedido,escrevedor);
    }
    
    protected static ArrayList<Pedido> carregarHistoricoDePedidosCancelados() throws IOException{
        File arquivo = new File("Historico de Pedidos Cancelados.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            ArrayList<Pedido> historicoDePedidosCancelados = new ArrayList<Pedido>();
            
            quantidadeDePedidosCancelados = 0;
            while(leitor.hasNext()){
                historicoDePedidosCancelados.add(quantidadeDePedidosCancelados,lerPedido(leitor));
                quantidadeDePedidosCancelados++;
            }
            leitor.close();
            return historicoDePedidosCancelados;
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
            return null;
        }
    }
    
    protected static void exibirHistoricoDePedidosCancelados() throws IOException{
        ArrayList<Pedido> historicoDePedidosCancelados = carregarHistoricoDePedidosCancelados();
        if(historicoDePedidosCancelados == null){
            System.out.print("Não há pedidos Cancelados\n");
        }
        else{
            for(int i=0;i < quantidadeDePedidosCancelados; i++){
                imprimirPedido(historicoDePedidosCancelados.get(i));
            }
        }
    }
    
    protected static void removerPedidoDaLista(int posicaoDoPedido){
        for(int i = posicaoDoPedido; i< quantidadeDePedidosEmAberto-1; i++){
            listaDePedidosEmAberto.add(i,listaDePedidosEmAberto.get(i+1));
        }
        listaDePedidosEmAberto.add(quantidadeDePedidosEmAberto - 1, null);        
    }
    
    protected static void fecharPedido() throws IOException{
        System.out.print("Digite o numero do pedido para fechamento:   ");
        
        Scanner leitor = new Scanner(System.in);
        int numeroDoPedido = leitor.nextInt();
        int posicaoDoPedido = retornarPosicaoDoPedidoViaNumero(numeroDoPedido);
        
        
        gravarPedidoEmHistorico(posicaoDoPedido);
        retirarItensDoEstoque(posicaoDoPedido);
        removerPedidoDaLista(posicaoDoPedido);
        quantidadeDePedidosEmAberto--;
    }
    
    protected static Pedido retornarPedidoPeloNumero(int numeroDoPedido){
        for(int i=0;i<quantidadeDePedidosEmAberto;i++){
            if(listaDePedidosEmAberto.get(i).numeroDoPedido == numeroDoPedido){
                return listaDePedidosEmAberto.get(i);
            }
        }
        return null;
    }
    
    protected static void aplicarAdicao(ArrayList<Item> itensNovos,int numeroDoPedido){
        int numeroDeMomento = listaDePedidosEmAberto.get(numeroDoPedido).quantidadeDeItensPedidos;
        
        for(int i=0  ;i< itensNovos.size() ;  i++){
            listaDePedidosEmAberto.get(numeroDoPedido).itensPedidos.add((numeroDeMomento+i),itensNovos.get(i));
        }
    }
    
    protected static void adicionarItemAoPedido(){
        Scanner leitor = new Scanner(System.in);
        int numeroDoPedido;
        Pedido pedidoTemporario;
        
        System.out.println("Digite o número do pedido:   ");
        numeroDoPedido = leitor.nextInt();
        pedidoTemporario = retornarPedidoPeloNumero(numeroDoPedido);
        
        if(pedidoTemporario == null){
            System.out.println("PEDIDO INEXISTENTE!!!\n\n");
        }
        else{
            ArrayList<Item> itensNovos;
            
            pedidoTemporario.itensPedidos = pedidoTemporario.selecionarItens(pedidoTemporario.itensPedidos);
            itensNovos = pedidoTemporario.itensPedidos;
            aplicarAdicao(itensNovos,numeroDoPedido);
        }
    }
    
    protected static void imprimirItensPedidosPeloCliente(Pedido pedido){
        int quantidadeDeItensPedidos = pedido.quantidadeDeItensPedidos;
        Item itemPedido;
        
        for(int i=0;i<quantidadeDeItensPedidos;i++){
            itemPedido = pedido.itensPedidos.get(i);
            
            System.out.print("Nome do item: "+itemPedido.nome);
            System.out.print("Nome do código: "+itemPedido.codigo);
            System.out.print("Numero de unidades pedidas: "+itemPedido.quantidadeReservada);
        }
    }
    
    protected static void aplicarExclusao(Item itemExcluido,int numeroDoPedido,Pedido pedido){
        restaurarUnidades(itemExcluido.quantidadeReservada,itemExcluido.nome);
        pedido.itensPedidos.get(pedido.retornarPosicaoDoitemPeloNome(itemExcluido.nome, pedido.itensPedidos)).quantidadeReservada -= itemExcluido.quantidadeReservada;
        listaDePedidosEmAberto.add(retornarPosicaoDoPedidoViaNumero(numeroDoPedido),pedido);
    }
    
    protected static void retirarItensDoPedido(){
        Scanner leitor = new Scanner(System.in);
        int numeroDoPedido;
        Pedido pedidoTemporario;
        
        System.out.println("Digite o número do pedido:   ");
        numeroDoPedido = leitor.nextInt();
        pedidoTemporario = retornarPedidoPeloNumero(numeroDoPedido);
        
        if(pedidoTemporario == null){
            System.out.println("PEDIDO INEXISTENTE!!!\n\n");
        }
        else{
            Item itemExcluido = new Item();
            
            do{
                imprimirItensPedidosPeloCliente(pedidoTemporario);
                System.out.print("Digite o código do ítem a ser excluido:   ");
                itemExcluido.codigo = leitor.nextInt();
                System.out.print("Digite o numero de unidades do ítem a ser excluidas:   ");
                itemExcluido.quantidadeReservada = leitor.nextInt();
                aplicarExclusao(itemExcluido,numeroDoPedido,pedidoTemporario);
                
                System.out.print("Desejas excluir retirar mais algum item?\nDigite y se sim ou qualquer outro caracter se não: ");
            }while(leitor.nextLine().matches("y"));
        }            
    }
    
    protected static void exibirHistoricoDePedidos() throws IOException{
        ArrayList<Pedido> historicoDePedidos = carregarHistoricoDePedidos();
        
        for(int i=0;i<quantidadeDePedidosEncerrados;i++){
            imprimirPedido(historicoDePedidos.get(i));
        }
    }
    
    protected static void imprimirData(Instante data){
        System.out.print(""+data.dia);
        System.out.print("/"+data.mes);
        System.out.print("/"+data.ano);
        System.out.print("Horário: "+data.hora);
        System.out.print(":"+data.minuto);
        System.out.print(":"+data.segundo);
        System.out.println();
    }
    
    protected static void imprimirDataDeSolicitacao(Instante data){
        System.out.print("Data de solicitação: ");
        imprimirData(data);
    }
    
    protected static void imprimirDataDeFechamento(Instante data){
        System.out.print("Data de fechamento: ");
        imprimirData(data);
    }
    
    protected static void imprimirPedido(Pedido pedido){
        System.out.print("\n\nNome do Cliente: "+pedido.clienteSolicitador.nome);
        System.out.print("\n\nC.P.F. do Cliente: "+pedido.clienteSolicitador.cpf);
        imprimirItensPedidosPeloCliente(pedido);
        imprimirDataDeSolicitacao(pedido.solicitacao);
        imprimirDataDeFechamento(pedido.fechamento);
    }
    
    protected static void listarPedidosEmAberto(){
        for(int i=0;i<quantidadeDePedidosEmAberto;i++){
            imprimirPedido(listaDePedidosEmAberto.get(i));
        }
    }
    
    protected static void gravarPedido(Pedido pedido,FileWriter escrevedor) throws IOException{
        
        escrevedor.write(Integer.toString(pedido.numeroDoPedido));
        escrevedor.write("\n");
        escrevedor.write(Integer.toString(pedido.quantidadeDeItensPedidos));
        escrevedor.write("\n");
        gravarCliente(pedido.clienteSolicitador,escrevedor);
        gravarData(pedido.solicitacao,escrevedor);
        gravarData(pedido.fechamento,escrevedor);
        gravarListaDeItens(pedido.itensPedidos,escrevedor);
    }
    
    protected static void salvarPedidosEmAberto() throws IOException{
        File arquivo = new File("Pedidos em Aberto.txt");
        FileWriter escrevedor = new FileWriter(arquivo);
        Pedido pedido;
        
        for(int i=0;i<quantidadeDePedidosEmAberto;i++){
            pedido = listaDePedidosEmAberto.get(i);
            gravarPedido(pedido,escrevedor);
        }
        escrevedor.close();
    }
    
    protected static Pedido lerPedido(Scanner leitor) throws IOException{
        Pedido pedidoTemporario = new Pedido();
        
        pedidoTemporario.numeroDoPedido = Integer.parseInt(leitor.nextLine());
        pedidoTemporario.quantidadeDeItensPedidos = Integer.parseInt(leitor.nextLine());
        pedidoTemporario.clienteSolicitador = lerCliente(leitor);
        pedidoTemporario.solicitacao = lerData(leitor);
        pedidoTemporario.fechamento = lerData(leitor);
        pedidoTemporario.itensPedidos = lerItensComprados(leitor,pedidoTemporario.quantidadeDeItensPedidos);
        return pedidoTemporario;
    }
    
    protected static void aplicarCancelamento(int numeroDoPedido) throws IOException{
        Pedido pedido = retornarPedidoPeloNumero(numeroDoPedido);
        
        for(int i=0;i<pedido.quantidadeDeItensPedidos;i++){
            restaurarUnidades(pedido.itensPedidos.get(i).quantidadeReservada,pedido.itensPedidos.get(i).nome);
        }
        gravarPedidoEmHistoricoDeCancelamento(pedido);
        listaDePedidosEmAberto.remove(retornarPosicaoDoPedidoViaNumero(numeroDoPedido));
    }
    
    protected static void cancelarPedido() throws IOException{
        Scanner leitor = new Scanner(System.in);
        int numeroDoPedido;
        
        System.out.print("\nDigite o número do pedido a ser cancelado:   ");
        numeroDoPedido = leitor.nextInt();
        
        if(retornarPedidoPeloNumero(numeroDoPedido) == null){
            System.out.print("\nPEDIDO INEXISTENTE!!!\n\n");
        }
        else{
            aplicarCancelamento(numeroDoPedido);
        }
    }
    
    protected static ArrayList<Pedido> carregarHistoricoDePedidos() throws IOException{
        File arquivo = new File("Historico de Pedidos.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            ArrayList<Pedido> historicoDePedidos = new ArrayList<Pedido>();
            
            quantidadeDePedidosEncerrados = 0;
            while(leitor.hasNext()){
                historicoDePedidos.add(quantidadeDePedidosEncerrados,lerPedido(leitor));
                quantidadeDePedidosEncerrados++;
            }
            leitor.close();
            return historicoDePedidos;
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
            return null;
        }
    }
    
    protected static void lerPedidosEmAberto() throws IOException{
        File arquivo = new File("Pedidos em Aberto.txt");
        
        if(arquivo.exists()){
            Scanner leitor = new Scanner(arquivo);
            
            listaDePedidosEmAberto.clear();
            quantidadeDePedidosEmAberto = 0;
            while(leitor.hasNext()){
                listaDePedidosEmAberto.add(quantidadeDePedidosEmAberto,lerPedido(leitor));
                quantidadeDePedidosEmAberto++;
            }
        }
        else{
            FileWriter criador = new FileWriter(arquivo);
            criador.close();
        }
    }    
    
    
    
    //****************************************************************************
    private static int menu(){
        int escolha;
        Scanner scan = new Scanner(System.in);
        
        System.out.print("*\n\n************************** LOJA ********************\n\n");
        System.out.print("1 - Cadastrar Fornecedor;\n");
        System.out.print("2 - Cadastrar Item;\n");
        System.out.print("3 - Realizar Compra;\n");
        System.out.print("4 - Cadastrar Cliente;\n");
        System.out.print("5 - Abrir Pedido;\n");
        System.out.print("6 - Finalizar Pedido;\n");
        System.out.print("7 - Consultar de dados de um item pelo nome;\n");
        System.out.print("8 - Consultar de preço de um item pelo código;\n");
        System.out.print("9 - Listar Clientes;\n");
        System.out.print("10 - Listar Fornecedores;\n");
        System.out.print("11 - Listar pedidos em aberto;\n");
        System.out.print("12 - Situação atual do estoque para um produto\n");
        System.out.print("13 - Resumo da situação estoque;\n");
        System.out.print("14 - Adicionar item(s) ao pedido;\n");
        System.out.print("15 - Remover item(s) do pedido:\n");
        System.out.print("16 - Exibir histórico de pedidos:\n");
        System.out.print("17 - Cancelar pedido:\n");
        System.out.print("18 - Exibir histórico de pedidos cancelados:\n");
        System.out.print("19 - Exibir histórico compras:\n");
        System.out.print("20 - Sair;\n");
        System.out.print("\n\nCHOOSE YOUR DESTINY:    ");
        escolha = scan.nextInt();
        return escolha;
    }
    
    protected static void realizarLeiturasFundamentais() throws IOException{
        leituraDosFornecedores();
        leituraDosItens();
        leituraDosClientes();
        lerPedidosEmAberto();
    }
    
//**************************** CASES ********************
    
    protected static void case1() throws IOException{
        cadastrarFornecedorViaTeclado();
        salvarFornecedores();
    }
    
    protected static void case2() throws IOException{
        cadastrarItemViaTeclado();
        salvarItens();
    }
    
    protected static void case3() throws IOException{
        realizarCompra();
        salvarItens();
        salvarHistoricoDeCompras();
    }
    
    protected static void case4() throws IOException{
        cadastrarClienteViaTeclado();
        salvarClientes();
    }
    
    protected static void case5() throws IOException{
        abrirPedido();
        salvarPedidosEmAberto();
    }
    
    protected static void case6() throws IOException{
        fecharPedido();
        salvarPedidosEmAberto();
    }
    
    protected static void case7() throws IOException{
        listarDadosDoItem();
    }
    
    protected static void case8() throws IOException{
        consultarPrecoDeUmItemPorCodigo();
    }
    
    protected static void case9(){
        listarClientes();
    }
    
    protected static void case10(){
        listarFornecedores();
    }
    
    protected static void case11(){
        listarPedidosEmAberto();
    }
    
    protected static void case12(){
        situacaoAtualDoEstoqueParaUmProduto();
    }
    
    protected static void case13(){
        resumoDasituacaoAtualDoEstoque();
    }
    
    protected static void case14() throws IOException{
        adicionarItemAoPedido();
        salvarPedidosEmAberto();
    }
    
    protected static void case15() throws IOException{
        retirarItensDoPedido();
        salvarPedidosEmAberto();
    }
    
    protected static void case16() throws IOException{
        exibirHistoricoDePedidos();
    }
    
    protected static void case17() throws IOException{
        cancelarPedido();
        salvarPedidosEmAberto();
    }
    
    protected static void case18() throws IOException{
        exibirHistoricoDePedidosCancelados();
    }
    
    protected static void case19() throws IOException{
        exibirHistoricoDeCompras();
    }
    
    //////////////////////////////////////////////////////////////////////////////////
    public static void main(String[] args) throws IOException{
        int escolha;
        
        do{
            escolha = menu();
            realizarLeiturasFundamentais();
            switch (escolha)
            {
                case 1:{
                    case1();
                    break;
                }
                case 2:{
                    if(quantidadeDeFornecedores == 0){
                        System.out.println("Por favor cadastre um fornecedor!!\n\n");
                        break;
                    }
                    case2();
                    break;
                }
                case 3:{
                    if(quantidadeDeItens == 0){
                        System.out.println("Por favor cadastre um Item!!\n\n");
                        break;
                    }
                    case3();
                    break;
                }
                case 4:{
                    case4();
                    break;
                }
                case 5:{
                    case5();
                    break;
                }
                case 6:{
                    case6();
                    break;
                }
                case 7:{
                    case7();
                    break;
                }
                case 8:{
                    case8();
                    break;
                }
                case 9:{
                    case9();
                    break;
                }
                case 10:{
                    case10();
                    break;
                }
                case 11:{
                    case11();
                    break;
                }
                case 12:{
                    case12();
                    break;
                }
                case 13:{
                    case13();
                    break;
                }
                case 14:{
                    case14();
                    break;
                }
                case 15:{
                    case15();
                    break;
                }
                case 16:{
                    case16();
                    break;
                }
                case 17:{
                    case17();
                    break;
                }
                case 18:{
                    case18();
                    break;
                }
                case 19:{
                    case19();
                    break;
                }
            }
        }while(escolha!=20);
    }
}
